package com.example.lettcode._202412._20241216;

/*
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

示例 1:
输入: s = "abab"
输出: true
解释: 可由子串 "ab" 重复两次构成。

示例 2:
输入: s = "aba"
输出: false

示例 3:
输入: s = "abcabcabcabc"
输出: true
解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)

提示：
1 <= s.length <= 104
s 由小写英文字母组成
 */
public class _459_chong_fu_de_zi_zi_fu_chuan {

    public static void main(String[] args) {
        String s = "abcabc";
        System.out.println(repeatedSubstringPattern4(s));
    }

    public static boolean repeatedSubstringPattern(String s) {
        if (s.length() == 1) {
            return false;
        }

        int[] ints = new int[26];
        char[] chars = s.toCharArray();
        for (char aChar : chars) {
            ints[aChar - 'a']++;
        }

        int count = 0;
        for (int anInt : ints) {
            if (count == 0) {
                count = anInt;
                break;
            }
        }

        if (s.length() % count != 0) {
            return false;
        }


        return true;
    }

    public boolean repeatedSubstringPattern2(String s) {
        return (s + s).indexOf(s, 1) != s.length();
    }

    /*
        1、存在子串，那么子串的长度必定小于等于s/2
        2、对于s.length % 遍历的i值 ！= 0 的不错处理，因为，存在子串，那么必定其子串的N倍
        3、当存在子串时，那么必定每个子串都是相等的，如果不等，则标识符设置为false
        4、一旦标识符为true，则表明，存在子串，否则为fasle
     */
    public static boolean repeatedSubstringPattern3(String s) {
        int n = s.length();
        for (int i = 1; i * 2 <= n; ++i) {
            if (n % i == 0) {
                boolean match = true;
                for (int j = i; j < n; ++j) {
                    if (s.charAt(j) != s.charAt(j - i)) {
                        match = false;
                        break;
                    }
                }
                if (match) {
                    return true;
                }
            }
        }
        return false;
    }

    public static boolean repeatedSubstringPattern5(String s) {
        int n = s.length();
        for (int i = 0; i * 2 <= n; i++) {
            if (i % 2 == 0) {
                boolean match = true;
                for (int j = i; j < n; j++) {
                    if (s.charAt(j) != s.charAt(j - i)) {
                        match = false;
                        break;
                    }
                }
                if (match) {
                    return true;
                }
            }
        }
        return false;
    }


    public static boolean repeatedSubstringPattern4(String s) {
        System.out.println((s + s).indexOf(s, 1));
        /*
            是重复的：
                字符串：abcabc

                s + s:
                    abcabcabcabc

                （s+s).indexof(1, s) -> 在abcabcabcabc中，从下标为1的位置开始查找出现abcabc的第一个位置， 第一个出现abcabc的位置是下标3的地方

                如果第一个出现的位置 ！= s的长度，说明，存在重复子串
                如果第一个出现的为值 == s的长度，说明，不存在重复子串

         */
        return (s + s).indexOf(s, 1) != s.length();
    }

    }
